home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / vision / magiceye / ddd / tools.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-07  |  9.0 KB  |  441 lines
  1. /*-------------------------------
  2. | Kommando-Zeile: Optionen laden
  3. | Damit man nicht immer denselben
  4. | Quark schreiben muß...
  5. --------------------------------*/
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <ctype.h>
  10. #include <tos.h>
  11.  
  12. #include "tools.h"
  13.  
  14.  
  15. /*-----
  16. | Sizes
  17. -------*/
  18. #define PATH_SIZE 200
  19. #define NAME_SIZE 14
  20.  
  21.  
  22. /*-----------------
  23. | globale Variablen
  24. -------------------*/
  25. long act_fil_sz;
  26. char *local_path = NULL;
  27.  
  28.  
  29. /*--------
  30. | atexit:
  31. ----------*/
  32. void free_lp( void );
  33.  
  34.  
  35. /*------------------------------------------------------------------
  36. | Alle Optionen einlesen.
  37. | Ausgabe: Anzahl der Optionen
  38. |                             == Index auf erste non-option in argv
  39. |               wenn format == prg_name [o1] [o2] [..] Parameter )
  40. --------------------------------------------------------------------*/
  41. int get_options( int argc, char **argv)
  42. {
  43.     int c;
  44.     int pos;
  45.  
  46.     for( c = 1; c < argc; c++ )
  47.     {
  48.         /*--------------
  49.         | Welche Option?
  50.         ----------------*/
  51.         pos = get_index( argv[c] );
  52.  
  53.         /*-------------------
  54.         | nix mehr -> Abbruch
  55.         ---------------------*/
  56.         if( pos < 0 )
  57.         {    break;
  58.         }
  59.  
  60.         /*----------------------------
  61.         | Wert berechnen und speichern
  62.         ------------------------------*/
  63.         liste[pos].value = liste[pos].function( argv[c] + strlen(liste[pos].option));
  64.         liste[pos].valid = TRUE;
  65.     }
  66.  
  67.     return c;
  68. }
  69.  
  70.  
  71. /*---------------------------------
  72. | Index in optionen-Liste ermitteln
  73. -----------------------------------*/
  74. int get_index( char *p )
  75. {
  76.     int c;
  77.     int ret;
  78.  
  79.     /*---------------------
  80.     | Default: nix gefunden
  81.     -----------------------*/
  82.     ret = -1;
  83.  
  84.     /*-----------------
  85.     | Liste durchsuchen
  86.     -------------------*/
  87.     for( c = 0; liste[c].function != NULL; c++ )
  88.     {
  89.         /*---------------------
  90.         | Gefunden?
  91.         | Index merken und raus
  92.         -----------------------*/
  93.         if( strncmp( p, liste[c].option, strlen( liste[c].option) ) == 0 )
  94.         {    ret = c;
  95.             break;
  96.         }
  97.     }
  98.  
  99.     return ret;
  100. }
  101.  
  102.  
  103.  
  104. /*---------------------------------------------------
  105. |            Umwandlungsroutinen
  106. -----------------------------------------------------*/
  107. void *get_number( char *p )
  108. {
  109.     return (void *)atoi( p );
  110. }
  111.  
  112. void *get_string( char *p )
  113. {
  114.     return (void *)p;
  115. }
  116.  
  117.  
  118. /*--------------------------------------------------------------------
  119. | File-IO-Routinen
  120. ----------------------------------------------------------------------*/
  121.  
  122. /*-------------------------------------------------------------------
  123. | File öffnen
  124. |       laden (ganz),
  125. |       schließen.
  126. |
  127. |
  128. | Eingaben: Pfad, Name, Modus.
  129. | Ausgaben: Adresse des Speicherbereichs, in den die Daten geladen wurden.
  130. |            Länge des Files steht
  131. |            - in globaler Variablen (long) act_fil_sz
  132. |            - bei Adresse - sizeof(long).
  133. |            Fehler: Adresse = NULL;
  134. |                    act_fil_sz=-1;
  135. |------------------------------------------------------------------
  136. | NB: File entfernen immer mit unload_file().
  137. -------------------------------------------------------------------*/
  138. void *load_file(char *pfad, char *name, char *mode)
  139. {
  140.     FILE *fp;
  141.     long size;
  142.     char *p;
  143.  
  144.     if( (fp=open_file(pfad, name, mode)) == NULL)
  145.     {
  146.         act_fil_sz=-1l;
  147.         return NULL;
  148.     }
  149.  
  150.     size=fsize(fp);
  151.     p=(char    *)malloc( size+sizeof(long) );
  152.     if(p==NULL)
  153.     {
  154.         close_file(fp);
  155.         act_fil_sz=-1l;
  156.         return NULL;
  157.     }
  158.  
  159.     size = 0L;
  160.     /*---------------------------
  161.     | File einlesen, Bytes zählen
  162.     -----------------------------*/
  163.     while( fread( p + sizeof( long )+ size, 1, 1, fp ) != 0L )
  164.     {    size++;
  165.     }
  166.  
  167.     close_file(fp);
  168.     act_fil_sz=size;
  169.     *(long *)p=size;
  170.  
  171.     return (void *)(p+sizeof(long));
  172. }
  173.  
  174.  
  175.  
  176. /*-------------------------------------------------------------------
  177. | Ein mit load_file() geladenes File
  178. |  aus Speicher entfernen.
  179. | Aktuelle Länge ist dann ungültig!
  180. -------------------------------------------------------------------*/
  181. void unload_file(char *p)
  182. {
  183.     if(p)
  184.         free(p-sizeof(long));
  185.     act_fil_sz=-1l;
  186. }
  187.  
  188.  
  189.  
  190.  
  191. /*-------------------------------------------------------------------
  192. | File öffnen:
  193. |--------------------------------------------------------------------
  194. | Eingabe: Pfad, Name und Modus
  195. | Ausgabe: FILE-Pointer oder NULL bei Fehler
  196. --------------------------------------------------------------------*/
  197. FILE *open_file( char *pfad, char *name, const char *mode)
  198. {
  199.     FILE *fp;
  200.     char dir[PATH_SIZE];
  201.  
  202.     get_path( dir );
  203.  
  204.     set_path( pfad );
  205.     fp=fopen( name, mode);
  206.  
  207.     set_path( dir );
  208.  
  209.     return fp;
  210. }
  211.  
  212.  
  213. /*-------------------------------------------------------------------
  214. | File schließen, der Vollständigkeit halber.
  215. -------------------------------------------------------------------*/
  216. int close_file(FILE *fp)
  217. {
  218.     int err;
  219.  
  220.     if(fp)
  221.     {    err=fclose(fp);
  222.         fp=NULL;
  223.     }
  224.     return err;
  225. }
  226.  
  227.  
  228.  
  229.  
  230. /* -------------------------------------------------------------------
  231. | Größe einer Datei ermittteln.
  232. ------------------------------------------------------------------- */
  233. long fsize(FILE *fp)
  234. {
  235.     long pos, size;
  236.  
  237.     pos=fseek(fp, 0, SEEK_CUR);
  238.     fseek(fp, 0, SEEK_END);
  239.     size=ftell(fp);
  240.     fseek(fp, pos, SEEK_SET);
  241.  
  242.     return size;
  243. }
  244.  
  245.  
  246. /*----------------------------------
  247. | Aus Eingabe Pfad und Namen holen.
  248. | String-Länge muß ausreichend sein.
  249. ------------------------------------*/
  250. int get_pn( char *p, char *n, char *inp)
  251. {
  252.     char *t;
  253.     long h;
  254.  
  255.     /*---------------
  256.     | Namen abtrennen
  257.     -----------------*/
  258.     t = get_name( inp );
  259.     strcpy( n, t );
  260.  
  261.     /*----------------
  262.     | Pfad auch
  263.     ------------------*/
  264.     if( t == inp )
  265.     {    strcpy( p, ".");
  266.     }else
  267.     {    strncpy( p, inp, h = strlen( inp ) - strlen( n ) );
  268.         p[h] = '\0' ;
  269.     }
  270.  
  271.     return 0;
  272. }
  273.  
  274.  
  275.  
  276. /* ---------------------------------------
  277. | Zeiger auf den Namen im Pfad holen.
  278. | i.e.: das, was hinter letzte '\\' steht.
  279. | Muß man selber kopieren!
  280. -----------------------------------------*/
  281. char *get_name( char *p)
  282. {
  283.     char *t;
  284.  
  285.     t = strrchr( p, '\\');    /* Namen suchen */
  286.     if( t == NULL )
  287.     {    t = strrchr( p, ':');
  288.     }
  289.  
  290.     if( t == NULL)
  291.     {    t = p;
  292.     }else
  293.     {    t++;
  294.     }
  295.  
  296.     return t;
  297. }
  298.  
  299.  
  300. /*---------------------------------
  301. | Pfad setzen
  302. | Mit oder ohne Laufwerk,
  303. | relativ oder absolut
  304. |----------------------------------
  305. | In dieser Routine wird
  306. | beim ersten Aufruf local_path
  307. | gesetzt. Relative Pfade beziehen
  308. | sich immer auf dieses Verzeichnis.
  309. |
  310. | NB:
  311. | relativen Pfaden darf das Laufwerk
  312. | vorangestellt sein. Darum ist also
  313. | das LW nicht teil des Pfad-Namens.
  314. | xxx
  315. | für jedes LW einen lokalen Pfad merken!
  316. |----------------------------------
  317. | Eingabe: String mit Pfad
  318. | Ausgabe: Neuer Pfad oder
  319. |          NULL bei Fehler
  320. -----------------------------------*/
  321. char *set_path( char *d )
  322. {
  323.     char op[PATH_SIZE], od;
  324.     int drv;
  325.     int ps;
  326.  
  327.     /*-------------------------
  328.     | Altes Drive & Pfad merken
  329.     ---------------------------*/
  330.     od=get_drv();
  331.     get_path( op );
  332.  
  333.     /*------------------------------
  334.     | Wenn noch nicht geschehen:
  335.     | Augenblicklichen Pfad erfragen
  336.     --------------------------------*/
  337.     if( local_path == NULL )
  338.     {
  339.         local_path = (char *)malloc( PATH_SIZE );
  340.         atexit( free_lp );
  341.         get_path( local_path );
  342.     }
  343.  
  344.  
  345.     /*---------------------------------
  346.     | Da fängt der eigentliche Pfad an
  347.     -----------------------------------*/
  348.     ps = 0;
  349.  
  350.     /*----------------
  351.     | Drive angegeben?
  352.     ------------------*/
  353.     if( d[1] == ':' )
  354.     {
  355.         ps = 2;
  356.         drv=toupper(d[0])-'A';
  357.         if( (set_drv(drv) && 1<<drv) == 0 )
  358.         {    set_drv( od );
  359.             return NULL;
  360.         }
  361.     }
  362.  
  363.     /*--------------------
  364.     | Relative Pfadangabe:
  365.     | lokalen Pfad setzen
  366.     ----------------------*/
  367.     if( d[ps] == '.' && ( d[ps+1] == '\0' || d[ps+1] == '\\' || d[ps+1] == '.') )
  368.     {
  369.         set_path( local_path );
  370.     }
  371.  
  372.     /*-----------
  373.     | Pfad setzen
  374.     -------------*/
  375.     if( set_dir( &d[ps] ) < 0 )
  376.     {    set_drv( od );
  377.         set_dir( op );
  378.         return NULL;
  379.     }
  380.  
  381.     /*-----------------------
  382.     | Der ganze aktuelle Pfad
  383.     -------------------------*/
  384.     get_path( d );
  385.  
  386.     return d;
  387. }
  388.  
  389. /*----------------------------------------
  390. | Speicher des local_path wieder freigeben
  391. ------------------------------------------*/
  392. void free_lp( void )
  393. {
  394.     if( local_path != NULL )
  395.     {    free( local_path );
  396.     }
  397. }
  398.  
  399. /*-----------------------------------
  400. | Pfad holen mit Laufwerk:
  401. |------------------------------------
  402. | Eingabe: Zeiger auf Speicherbereich
  403. | Ausgabe: Zeiger auf Speicherbereich
  404. ------------------------------------*/
  405. char *get_path(char *p)
  406. {
  407.     strcpy(p," :");
  408.     p[0]=get_drv()+'A';
  409.  
  410.     get_dir(&p[2], 0);
  411.  
  412.     /*---------------------------------------------------
  413.     | Irgendwo stand mal, (ich denke, in der ST-Computer)
  414.     | ein Pfad müsse IMMER mit '\\' abgeschlossen sein.
  415.     -----------------------------------------------------*/
  416.     if( p[strlen( p )] != '\\' )
  417.     {    strcat( p, "\\");
  418.     }
  419.  
  420.     return p;
  421. }
  422.  
  423. /*------------------------------------------------------------------
  424. |                      TOS abhängig:
  425. --------------------------------------------------------------------*/
  426. int get_drv( void )
  427. {    return Dgetdrv( );
  428. }
  429.  
  430. long set_drv( int drv )
  431. {    return Dsetdrv( drv );
  432. }
  433.  
  434. int set_dir( char *p)
  435. {    return Dsetpath( p );
  436. }
  437.  
  438. int get_dir( char *p, int drv)
  439. {    return Dgetpath( p, drv );
  440. }
  441.